package projectsys.core.utils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DateUtils {
	/* 默认日期格式 */
	private static String format = "yyyy-MM-dd HH:mm:ss";

	private static String format14 = "yyyyMMddHHmmss";
	
	private static String format8="yyyyMMdd";
	
	public static final String FORMAT_8 = "yyyyMMdd";
	public static final String FORMAT_14 = "yyyyMMddHHmmss";
	public static final String FORMAT_NORMAL = "yyyy-MM-dd HH:mm:ss";
	public static final String YEAR = "year";
	public static final String MONTH = "month";
	public static final String DAY = "day";
	public static final String FORMAT_TIME6 = "HHmmss";
	
	
	
	/**
	 * 获得当前时间字符串，格式为yyyy-MM-dd HH:mm:ss
	 * 
	 * @return 当前时间字符串
	 */
	public static String getCurrentTimeAsString() {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		return sdf.format(new Date());
	}

	/**
	 * 获得当前时间的14位字符串，格式为yyyyMMddHHmmss
	 * 
	 * @return 当前时间14位字符串
	 */
	public static String getCurrentTimeAs14String() {
		SimpleDateFormat sdf = new SimpleDateFormat(format14);
		return sdf.format(new Date());
	}

	/**
	 * 获得当前时间的8位字符串，格式为yyyyMMdd
	 * 
	 * @return 当前时间8位字符串
	 */
	public static String getCurrentTimeAs8String() {
		SimpleDateFormat sdf = new SimpleDateFormat(format8);
		return sdf.format(new Date());
	}
	/**
	 * 获得当前时间的6位字符串，格式为HHmmss
	 * 
	 * @return 当前时间6位字符串
	 */
	public static String getCurrentTimeAst6String() {
		SimpleDateFormat sdf = new SimpleDateFormat(FORMAT_TIME6);
		return sdf.format(new Date());
	}
	/**
	 * 将指定日期转换为字符串，格式为yyyy-MM-dd HH:mm:ss
	 * 
	 * @param date日期
	 * @return 日期字符串
	 */
	public static String DateToString(Date date) {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		return date == null ? null : sdf.format(date);
	}

	/**
	 * 将日期转换为指定格式的字符串
	 * 
	 * @param date日期
	 *            ，format格式
	 * @return 日期字符串
	 */
	public static String DateToString(Date date, String format) {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		return date == null ? null : sdf.format(date);
	}

	/**
	 * 将字符串转换为指定格式的日期时间
	 * 
	 * @param strDate
	 *            日期字符串
	 * @param pattern
	 *            日期格式，与strDate格式匹配
	 */
	public static Date parseToDateTime(String strDate, String pattern) {
		try {
			Date parse = new SimpleDateFormat(pattern).parse(strDate);
			return StringUtils.isBlank(strDate) ? null : new SimpleDateFormat(
					pattern).parse(strDate);
			
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 将字符串转换为指定格式的日期字符串
	 * 
	 * @param strDate
	 *            日期字符串
	 * @param pattern
	 *            日期格式，与strDate格式匹配 * @param format要转换成的日期格式
	 * @return
	 */
	public static String parseToDateTime(String strDate, String pattern,
			String format) {
		Date date = parseToDateTime(strDate, pattern);
		if (date == null) {
			return "";
		}
		return DateToString(date, format);
	}

	/**
	 * 将字符串转换为默认格式的日期字符串（yyyyMMddHHmmss）
	 * 
	 * @param strDate
	 *            日期字符串
	 * @param pattern
	 *            日期格式，与strDate格式匹配
	 * @return
	 */
	public static String parseTo14DateTime(String strDate, String pattern) {
		Date date = parseToDateTime(strDate, pattern);
		if (date == null) {
			return "";
		}
		return DateToString(date, format14);
	}

	/**
	 * 将字符串转换为默认格式的日期字符串（yyyyMMddHHmmss）
	 * 
	 * @param strDate
	 *            日期字符串
	 * @param format
	 *            要转换成的日期格式
	 * @return
	 */
	public static String parse14StringToDateTime(String strDate, String format) {
		return parseToDateTime(strDate, format14, format);
	}

	/**
	 * 将字符串转换为默认格式的日期字符串（yyyyMMddHHmmss to yyyy-MM-dd HH:mm:ss）
	 * 
	 * @param strDate
	 *            日期字符串
	 * @return
	 */
	public static String parse14StringToDate(String strDate) {
		return parseToDateTime(strDate, format14, format);
	}

	/*****
	 * 根据给定的时间获得该时间的毫秒数
	 * @param date 传过来的时间值
	 * @return
	 */
	public static long getDateMesl(Date date){
		long mselDate = 0;
		mselDate = date.getTime();
		return mselDate;
	}
	/******
	 * 根据字符串获得毫秒数
	 * @param dateStr 时间字符串
	 * @param formate yyyyMMddHHmmss
	 * @return
	 */
	public static long getDateHaoMiao(String dateStr,String formate){
		SimpleDateFormat sdf = new SimpleDateFormat(formate);
		long mseldate = 0;
		try {
			mseldate = sdf.parse(dateStr).getTime();
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return mseldate;
	}
	/*******
	 * 根据传入的时间字符串判断是否和当前时间是否相同
	 * @param dateStr 时间字符串
	 * @param formate yyyyMMddHHmmss
	 * @return
	 */
	public static boolean isToDay(String dateStr,String formate){
		SimpleDateFormat sdf = new SimpleDateFormat(formate);
		String todayStr = sdf.format(new Date());
		if(todayStr!=null&&!todayStr.equals("")&&dateStr!=null&&!dateStr.equals("")
				&&dateStr.equals(todayStr)){
			return true;
		}else{
			return false;
		}
	}
	/*******
	 * 根据年月日构造一个日期
	 * @param year 年
	 * @param month 月
	 * @param day 日
	 * @return 
	 */
	public static Date getDate(int year,int month,int day){
		Calendar cal = Calendar.getInstance();
		cal.set(year, month-1, day,0,0,0);
		return cal.getTime();
	}
	/*******
	 * 根据日期，时分秒构造一个完整日期
	 * @param date 日期
	 * @param hour 时
	 * @param min 分
	 * @param sec 秒
	 * @return 返回一个时间
	 */
	public static Date getDate(Date date,int hour,int min,int sec){
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.set(Calendar.HOUR,hour);
		cal.set(Calendar.MINUTE,min);
		cal.set(Calendar.SECOND,sec);
		return cal.getTime();
	}
	/*****
	 * 判断所给的时间是否为月尾
	 * @param date
	 * @return Boolean
	 */
	public static boolean isEndOfTheMonth(Date date){
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		int maxDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
		if(cal.get(Calendar.DATE)==maxDay){
			return true;
		}else{
			return false;
		}
	}
	/*******
	 * 判断所给的时间是否是年末
	 * @param date
	 * @return
	 */
	public static boolean isEndOfTheYear(Date date){
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		if((cal.get(Calendar.MONTH)+1==12)&&(cal.get(Calendar.DATE)==31)){
			return true;
		}else{
			return false;
		}
	}
	/**
	 * 根据日期获得月尾
	 * @param date Date
	 * @return int
	 */
	public static final int getLastDayOfTheMonth(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);

		return cal.getActualMaximum(Calendar.DAY_OF_MONTH);
	}
	/**
	 * 判断日期是否为月首
	 * @param date Date
	 * @return true or false
	 */
	public static final boolean isStartOfTheMonth(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);

		if (cal.get(Calendar.DATE) == 1) {
			return true;
		}

		return false;
	}
	/**
	 * 获得日期中的年
	 * @param date Date
	 * @return int
	 */
	public static final int getYear(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		return cal.get(Calendar.YEAR);

	}
	/**
	 * 获得日期中的月份
	 * @param date Date
	 * @return int
	 */
	public static final int getMonth(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		return cal.get(Calendar.MONTH);

	}
	/**
	 * 获得日期中天
	 * @param date Date
	 * @return int
	 */
	public static final int getDay(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		return cal.get(Calendar.DATE);

	}
	/**
	 * 给日期增加天数
	 * @param date 日期
	 * @param numDays 增加的天数
	 * @return 增加后的日期
	 */
	public static Date addDaysToDate(Date date, int numDays) {
		if (date == null) {
			return null;
		}
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.add(Calendar.DATE, numDays);
		return c.getTime();
	}
	/**
	 * 给日期增加小时
	 * @param date 日期
	 * @param numHours 增加的小时数
	 * @return 增加后的日期
	 */
	public static Date addHoursToDate(Date date, int numHours) {
		if (date == null) {
			return null;
		}

		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.add(Calendar.HOUR_OF_DAY, numHours);

		return c.getTime();
	}

	/**
	 * 给日期增加分钟
	 * @param date 日期
	 * @param numMins 增加的分钟数
	 * @return 增加后的日期
	 */
	public static Date addMinutesToDate(Date date, int numMins) {
		if (date == null) {
			return null;
		}

		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.add(Calendar.MINUTE, numMins);

		return c.getTime();
	}

	/**
	 * 给日期增加月份
	 * @param date 日期
	 * @param numMonths 增加的月数
	 * @return 增加后的日期
	 */
	public static Date addMonthsToDate(Date date, int numMonths) {
		if (date == null) {
			return null;
		}
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.add(Calendar.MONTH, numMonths);
		return c.getTime();
	}

	/**
	 * 给日期增加年份
	 * @param date 日期
	 * @param numYears 增加的年数
	 * @return 增加后的日期
	 */
	public static Date addYearsToDate(Date date, int numYears) {
		if (date == null) {
			return null;
		}
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.add(Calendar.YEAR, numYears);
		return c.getTime();
	}
	/*****
	 * 判断是否为闰年
	 * @param d
	 * @return
	 */
	public static boolean isLeap(Date d) {
		int y = getYear(d);
		return  ((y % 4) == 0 && (y % 100) != 0) || (y % 400 == 0);
	}
	
	/**
	 * 获取两个日期之间相差的分数
	 * @param s1 小的时间字符串
	 * @param s2 大的时间字符串
	 * @param format 字符串时间的格式
	 * @return
	 */
	public static long hqxcfs(String s1, String s2, String format) {
		SimpleDateFormat dfs = new SimpleDateFormat(format);
		Date begin = null;
		Date end = null;
		try {
			begin = dfs.parse(s1);
			end = dfs.parse(s2);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		long between = (end.getTime() - begin.getTime()) / 1000;// 除以1000是为了转换成秒
		long min = between / 60;
		return min;
	}
	
	/*******
	 * 获取两个日期之间相差的天数
	 * @param s1 小的时间字符串
	 * @param s2 大的时间字符串
	 * @param format 字符串时间的格式
	 * @return
	 */
    public static int hqxcts(String s1,String s2,String format){
         SimpleDateFormat df = new SimpleDateFormat(format);
		Date d1 =null;
		Date d2 = null;
		try {
			d1 = df.parse(s1);
			d2 = df.parse(s2);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		
		Calendar c1 = Calendar.getInstance();
		Calendar c2 = Calendar.getInstance();
		c1.setTime(d1);
		c2.setTime(d2);
		int betweenYears = c2.get(Calendar.YEAR)-c1.get(Calendar.YEAR);
		int betweenDays = c2.get(Calendar.DAY_OF_YEAR)-c1.get(Calendar.DAY_OF_YEAR);
		for(int i=0;i<betweenYears;i++){
			c1.set(Calendar.YEAR,(c1.get(Calendar.YEAR)+1));
			betweenDays+=c1.getMaximum(Calendar.DAY_OF_YEAR);
		}
        return betweenDays;
    }
    public static String getDatetoString(String dateStr){
		  if(dateStr.length()==14){
			  dateStr=DateUtils.parseToDateTime(dateStr, "yyyyMMddHHmmss", "yyyy年MM月dd日 HH:mm:ss");
		  }else if(dateStr.length()==12){
			  dateStr=DateUtils.parseToDateTime(dateStr, "yyyyMMddHHmm", "yyyy年MM月dd日 HH:mm");
		  }else if(dateStr.length()==8){
				  dateStr=DateUtils.parseToDateTime(dateStr, "yyyyMMdd", "yyyy年MM月dd日");
		  }else if(dateStr.length()==4){
			   dateStr=DateUtils.parseToDateTime(dateStr, "HHmm", "HH:mm");
		  }
		  return dateStr;
	  }

    /**
     * 根据字符串时间操作
     * @author qdz
     * @createDate 2018年8月20日 下午3:23:00
     * @updateDate 2018年8月20日 下午3:23:00
     * @version 1.0
     * @param dateStr 时间字符串
     * @param format 格式类型yyyyMMdd
     * @param type  YEAR or MONTH or DAY
     * @param nums 增加的天数
     * @return
     */
    public static String operateStrDate(String dateStr, String format, String type, int nums){
    	Date date = null;
//    	switch (type) {
//	    	case YEAR:
//				date = addYearsToDate(parseToDateTime(dateStr, format), nums);
//				break;
//			case MONTH:
//				date = addMonthsToDate(parseToDateTime(dateStr, format), nums);
//				break;
//			case DAY:
//				date = addDaysToDate(parseToDateTime(dateStr, format), nums);
//				break;
//			default:
//				break;
//		}
    	if(YEAR.equals(type)){
    		date = addYearsToDate(parseToDateTime(dateStr, format), nums);
    	}else if(MONTH.equals(type)){
    		date = addMonthsToDate(parseToDateTime(dateStr, format), nums);
    	}else if(DAY.equals(type)){
    		date = addDaysToDate(parseToDateTime(dateStr, format), nums);
    	}
    	return DateToString(date, format);
    }
    
    /**
     * 将带时间格式的字符串按精确度转为时间戳
     * @author qdz
     * @createDate 2018年11月20日 上午11:10:57
     * @updateDate 2018年11月20日 上午11:10:57
     * @version 1.0
     * @param str 2018-11-20
     * @param acc 精确度,如10,则是化出来的时间戳除以10
     * @return
     */
    public static String dateStrToTimeStamp(String str, int acc){
		SimpleDateFormat sdf = null;
		str = str.replaceAll("-", "").replaceAll(":", "").replaceAll(" ", "");
		switch (str.length()){
			case 4:
				sdf = new SimpleDateFormat("yyyy");
				break;
			case 6:
				sdf = new SimpleDateFormat("yyyyMM");
				break;
			case 8:
				sdf = new SimpleDateFormat("yyyyMMdd");
				break;
			case 10:
				sdf = new SimpleDateFormat("yyyyMMddHH");
				break;
			case 12:
				sdf = new SimpleDateFormat("yyyyMMddHHmm");
				break;
			case 14:
				sdf = new SimpleDateFormat("yyyyMMddHHmmss");
				break;
			default:
				sdf = new SimpleDateFormat("yyyyMMddHHmmss");
				break;
		}
		try {
			return (sdf.parse(str).getTime() / acc )+ "";
		} catch (ParseException e) {
			
		}
		return "";
	}
    
    /**
     * 获取当前周的第一天(周一的日期)
     * lxy
     * 2019年5月23日
     * @return
     */
    public static String getFirstDateOfWeek(Date date) {
    	Calendar cal = Calendar.getInstance();
    	cal.setTime(date);
    	int d = 0;
    	if(cal.get(Calendar.DAY_OF_WEEK) == 1) {
    		d = -6;
    	}else {
    		d = 2 - cal.get(Calendar.DAY_OF_WEEK);
    	}
    	cal.add(Calendar.DAY_OF_WEEK, d);
    	String day = new SimpleDateFormat("yyyy-MM-dd").format(cal.getTime());
    	return day;
    }
    
    /**
     * 获取周的第一天(周一的日期)
     * lxy
     * 2019年7月3日
     * @param dateStr
     * @param format
     * @return
     */
    public static String getFirstDateOfWeek(String dateStr, String pattern, String format) {
    	SimpleDateFormat sdf = new SimpleDateFormat(pattern);
    	Date date = null;
    	try {
			date = sdf.parse(dateStr);
		} catch (ParseException e) {
			e.printStackTrace();
		}
    	if(date != null) {
    		return getFirstDateOfWeek(date, format);
    	}
    	return null;
    }
    /**
     * 获取周的第一天(周一的日期)
     * lxy
     * 2019年7月4日
     * @param date
     * @param format
     * @return
     */
    public static String getFirstDateOfWeek(Date date, String format) {
    	Calendar cal = Calendar.getInstance();
    	cal.setTime(date);
    	int d = 0;
    	if(cal.get(Calendar.DAY_OF_WEEK) == 1) {
    		d = -6;
    	}else {
    		d = 2 - cal.get(Calendar.DAY_OF_WEEK);
    	}
    	cal.add(Calendar.DAY_OF_WEEK, d);
    	String day = new SimpleDateFormat(format).format(cal.getTime());
    	return day;
    }
    
    /**
     * 获取一周的最后一天(周末的日期)
     * lxy
     * 2019年7月3日
     * @param date
     * @return
     */
    public static String getLastDateOfWeek(Date date) {
    	Calendar cal = Calendar.getInstance();
    	cal.setTime(date);
    	int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
    	if(dayWeek != 1) {
    		cal.add(Calendar.DATE, 7);
    	}
    	cal.set(Calendar.DAY_OF_WEEK, 1);
    	String day = new SimpleDateFormat("yyyy-MM-dd").format(cal.getTime());
    	return day;
    }
    
    /**
     * 获取一周的最后一天(周末的日期)
     * lxy
     * 2019年7月3日
     * @param dateStr
     * @param format
     * @return
     */
    public static String getLastDateOfWeek(String dateStr, String pattern, String format) {
    	SimpleDateFormat sdf = new SimpleDateFormat(pattern);
    	Date date = null;
    	try {
			date = sdf.parse(dateStr);
		} catch (ParseException e) {
			e.printStackTrace();
		}
    	if(date != null) {
    		return getLastDateOfWeek(date, format);
    	}
    	return null;
    }
    
    /**
     * 获取一周的最后一天(周末的日期)
     * lxy
     * 2019年7月4日
     * @param date
     * @param format
     * @return
     */
    public static String getLastDateOfWeek(Date date, String format) {
    	Calendar cal = Calendar.getInstance();
    	cal.setTime(date);
    	int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
    	if(dayWeek != 1) {
    		cal.add(Calendar.DATE, 7);
    	}
    	cal.set(Calendar.DAY_OF_WEEK, 1);
    	
    	String day = new SimpleDateFormat(format).format(cal.getTime());
    	return day;
    }
    
    /**
     * 获取指定月份的第一天和最后一天
     * lxy
     * 2019年5月30日
     * @param monthStr
     * @return
     */
	public static Map<String, String> getMonthDate(String monthStr) {
		Map<String, String> result = new HashMap<String, String>();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		
		String[] strArr = monthStr.split("-");
		
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.YEAR,  Integer.parseInt(strArr[0]));
		cal.set(Calendar.MONTH, Integer.parseInt(strArr[1]) -1);
		cal.set(Calendar.DAY_OF_MONTH, 1);
		String first = sdf.format(cal.getTime());
		
		cal = Calendar.getInstance();
		cal.set(Calendar.YEAR,  Integer.parseInt(strArr[0]));
		cal.set(Calendar.MONTH, Integer.parseInt(strArr[1]));
		cal.set(Calendar.DAY_OF_MONTH, 0);
		String last = sdf.format(cal.getTime());
		
		result.put("first", first);
		result.put("last", last);
		return result;
	}
	
	/**
	 * 根据两个日期,获取日期之间的每一天
	 * lxy
	 * 2019年5月30日
	 * @param first
	 * @param last
	 * @return
	 */
	public static List<String> getEveryDayByMonth(String first, String last) {
		return getEveryDayByMonth(first, last, "yyyy-MM-dd");
	}

	/**
	 * 根据两个日期,获取日期之间的每一天
	 * lxy
	 * 2019年5月30日
	 * @param first
	 * @param last
	 * @param pattern
	 * @return
	 */
	public static List<String> getEveryDayByMonth(String first, String last, String pattern) {
		List<String> result = new ArrayList<String>();
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		
		try {

			Date start = sdf.parse(first);
			Date end = sdf.parse(last);
			
			Calendar calStart = Calendar.getInstance();
			calStart.setTime(start);
			
			Calendar calEnd = Calendar.getInstance();
			calEnd.setTime(end);
			
			calEnd.add(Calendar.DATE, +1);
			while(calStart.before(calEnd)) {
				result.add(sdf.format(calStart.getTime()));
				calStart.add(Calendar.DAY_OF_YEAR, 1);
			}
			
		} catch (ParseException e) {
			e.printStackTrace();
		}
		
		return result;
	}
	
	/**
	 * 获取工作日天数（只去除周末）
	 * @author qdz
	 * @createDate 2019年7月16日 上午9:45:44
	 * @updateDate 2019年7月16日 上午9:45:44
	 * @version 1.0
	 * @param dateStart yyyyMMdd
	 * @param dateEnd yyyyMMdd
	 * @param pattern
	 * @return
	 */
	public static int calculateWorkDay(String dateStart, String dateEnd) {
		dateStart = dateStart.substring(0, 8);
		dateEnd = dateEnd.substring(0, 8);
		List<String> list = calculateWorkDay(dateStart, dateEnd, "yyyyMMdd");
		
		return list == null ? 0 : list.size();
	}
	
	/**
	 * 获取工作日列表（只去除周末）
	 * @author qdz
	 * @createDate 2019年7月16日 上午9:45:44
	 * @updateDate 2019年7月16日 上午9:45:44
	 * @version 1.0
	 * @param dateStart
	 * @param dateEnd
	 * @param pattern
	 * @return
	 */
	public static List<String> calculateWorkDay(String dateStart, String dateEnd, String pattern) {
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		Calendar calendarStart = Calendar.getInstance();
		Calendar calendarEnd = Calendar.getInstance();
		
		List<String> list = null;
		try {
			list = new ArrayList<String>();
			
			Date d1 = sdf.parse(dateStart);
			calendarStart.setTime(d1);
			
			Date d2 = sdf.parse(dateEnd);
			calendarEnd.setTime(d2);
			
			do {
				int dayOfWeek = calendarStart.get(Calendar.DAY_OF_WEEK);
				if(dayOfWeek != 7 && dayOfWeek != 1) {
					list.add(sdf.format(calendarStart.getTime()));
				}
				calendarStart.add(Calendar.DAY_OF_YEAR, 1);
			} while (!calendarStart.after(calendarEnd));
			
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return list;
	}


	/**
	 * 判断当天是否是周六或者周末,是:true,否:false
	 * lxy
	 * @param nowDate
	 * @return
	 * 2019年7月16日
	 */
	public static boolean todayIsWeekend(String nowDate) {
		boolean flag = false;
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		Date date; 
		try {
			date = sdf.parse(nowDate);
			Calendar cal = Calendar.getInstance();
			cal.setTime(date);
			int i = cal.get(Calendar.DAY_OF_WEEK);
			System.out.println(i);
			//是周末
			if(i == 1 || i == 7) {
				flag = true;
			}else {
				flag = false;
			}
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return flag;
	}
	
	public static String StringLeftCompletionWithZero(String sourceStr, int length) {
		return stringCompletion(true, sourceStr, "0", length);
	}
	
	/**
	 * 字符串右按0补齐,常用于时间补齐
	 * @author qdz
	 * @createDate 2019年7月17日 下午10:02:16
	 * @updateDate 2019年7月17日 下午10:02:16
	 * @version 1.0
	 * @param sourceStr
	 * @param length
	 * @return
	 */
	public static String StringRightCompletionWithZero(String sourceStr, int length) {
		return stringCompletion(false, sourceStr, "0", length);
	}
	
	/**
	 * 将给定字符串按左或右补齐
	 * @author qdz
	 * @createDate 2019年7月17日 下午9:43:27
	 * @updateDate 2019年7月17日 下午9:43:27
	 * @version 1.0
	 * @param ifLeft true:左补齐, false: 右补齐
	 * @param sourceStr 源字符串
	 * @param completionStr 补齐所用字符串
	 * @param length 补齐长度
	 * @return
	 */
	public static String stringCompletion(boolean isLeft, String sourceStr, String completionStr, int length) {
		if(completionStr == null || completionStr.isEmpty()) {
			completionStr = "0";
		}
		
		if(sourceStr == null || sourceStr.isEmpty()) {
			sourceStr = "";
		}
		
		if(length < 0) {
			return sourceStr;
		}
		
		StringBuffer sb = new StringBuffer(sourceStr);
		while(sb.length() < length) {
			if(isLeft) {
				sb.insert(0, completionStr);
			}else {
				sb.append(completionStr);
			}
		}
		return sb.toString();
	}
	
	/**
	 * 判断给定时间是否处于某一时间段内,如果处于该时间段内,返回true,否则返回false
	 * lxy
	 * @param time		给定时间字符串
	 * @param start		时间段开始
	 * @param end		时间段结束
	 * @param pattern	时间格式,三者必须统一
	 * @return
	 * 2019年7月17日
	 */
	public static boolean isInPeriodOfTime(String time, String start, String end, String pattern) {
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		
		boolean flag = false;
		
		Date date = null;
		Date startDate = null;
		Date endDate = null;
		
		try {
			date = sdf.parse(time);
			startDate = sdf.parse(start);
			endDate = sdf.parse(end);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		Calendar dateCal = Calendar.getInstance();
		Calendar startCal = Calendar.getInstance();
		Calendar endCal = Calendar.getInstance();
		dateCal.setTime(date);
		startCal.setTime(startDate);
		endCal.setTime(endDate);
		
		if(startCal.before(dateCal) && dateCal.before(endCal)) {
			flag = true;
		}
		return flag;
	}
	
	/**
	 * 
	 * lxy
	 * @param date
	 * @param start
	 * @param end
	 * @param pattern
	 * @return
	 * 2019年7月17日
	 */
	public static boolean isInPeriodOfTime(Date date, String start, String end, String pattern) {
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		String time = sdf.format(date);
		return isInPeriodOfTime(time, start, end, pattern);
	}
}
